/**
 * 登录状态检测工具
 * 统一处理用户登录状态检查和过期提示
 */
import config from '@/api/config.js'
import cacheManager from '@/utils/cacheManager.js'
import { API_CONFIG } from '@/api/config.js'
import { trackEvent } from '@/utils/eventTracker.js'

// 防止重复弹出登录弹窗的全局变量
let isLoginModalShowing = false

/**
 * 获取登录弹窗显示状态
 */
export function getLoginModalStatus() {
  return isLoginModalShowing
}

/**
 * 设置登录弹窗显示状态
 */
export function setLoginModalStatus(status) {
  isLoginModalShowing = status
}

/**
 * 获取当前页面路径
 * @returns {string} 当前页面路径（包含参数）
 */
function getCurrentPagePath() {
  const pages = getCurrentPages()
  
  if (pages.length > 0) {
    // 打印所有页面信息
    
    const currentPage = pages[pages.length - 1]
    let fullPath = '/' + currentPage.route
    
    // 获取页面参数
    if (currentPage.options && Object.keys(currentPage.options).length > 0) {
      // 手动拼接参数，避免使用小程序不支持的 URLSearchParams
      const paramPairs = []
      for (const key in currentPage.options) {
        if (currentPage.options.hasOwnProperty(key)) {
          paramPairs.push(`${encodeURIComponent(key)}=${encodeURIComponent(currentPage.options[key])}`)
        }
      }
      if (paramPairs.length > 0) {
        fullPath += '?' + paramPairs.join('&')
      }
    }
    return fullPath
  }
  
  return '/pages/index'
}

/**
 * 保存来源页面路径
 * @param {string} sourcePage 来源页面路径
 */
function saveSourcePage(sourcePage) {
  uni.setStorageSync('loginSourcePage', sourcePage)
}

/**
 * 获取保存的来源页面路径
 * @returns {string} 来源页面路径
 */
export function getSourcePage() {
  const sourcePage = uni.getStorageSync('loginSourcePage')
  return sourcePage || '/pages/index'
}

/**
 * 清除保存的来源页面路径
 */
export function clearSourcePage() {
  uni.removeStorageSync('loginSourcePage')
}

/**
 * 检查用户登录状态
 * @param {Object} options 配置选项
 * @param {boolean} options.showToast 是否显示提示信息，默认true
 * @param {boolean} options.autoRedirect 是否自动跳转到登录页，默认true
 * @param {boolean} options.autoWechatLogin 是否自动执行微信登录，默认true
 * @param {string} options.redirectUrl 跳转的登录页面URL，默认'/pages/login'
 * @param {string} options.sourcePage 来源页面路径，如果不传则自动获取当前页面
 * @returns {Object} 返回检查结果 { isLoggedIn: boolean, token: string, userId: string }
 */
export function checkLoginStatus(options = {}) {
  const {
    showToast = true,
    autoRedirect = true,
    autoWechatLogin = true,
    redirectUrl = '/pages/login',
    sourcePage
  } = options

  // 若已有登录弹窗在显示，避免重复弹窗
  if (showToast && isLoginModalShowing) {
    return {
      isLoggedIn: false,
      token: '',
      userId: '',
      name: '',
      nickName: '',
      avatar: ''
    }
  }

  // 获取token
  const token = uni.getStorageSync('App-Token')
  
  // 获取用户信息（优先从store获取，然后从storage获取）
  let userId = ''
  let name = ''
  let nickName = ''
  let avatar = ''
  
  try {
    // 尝试从store获取
    const app = getApp()
    if (app && app.$store && app.$store.state && app.$store.state.user) {
      const userState = app.$store.state.user
      userId = userState.id
      name = userState.name
      nickName = userState.nickName
      avatar = userState.avatar
    }
    
    // 如果store中没有，从storage获取
    if (!userId) {
      const storageData = uni.getStorageSync('storage_data') || {}
      userId = storageData['userId'] || storageData['user_id'] || uni.getStorageSync('userId')
      name = storageData['user_name'] || uni.getStorageSync('user_name') || ''
      nickName = storageData['user_nickName'] || uni.getStorageSync('user_nickName') || ''
      avatar = storageData['user_avatar'] || uni.getStorageSync('user_avatar') || ''
    }
  } catch (error) {
    console.error('获取用户信息失败:', error)
    // 从storage获取作为备选方案
    const storageData = uni.getStorageSync('storage_data') || {}
    userId = storageData['userId'] || storageData['user_id'] || uni.getStorageSync('userId')
    name = storageData['user_name'] || uni.getStorageSync('user_name') || ''
    nickName = storageData['user_nickName'] || uni.getStorageSync('user_nickName') || ''
    avatar = storageData['user_avatar'] || uni.getStorageSync('user_avatar') || ''
  }
  
  // 检查组织切换
  checkOrgSwitch(userId)

  // 检查token是否存在
  if (!token) {
    // 如果传入了sourcePage参数，则保存它
    if (sourcePage && sourcePage !== '/pages/login') {
      saveSourcePage(sourcePage)
    }
    // 注意：不再自动获取当前页面路径，因为401错误处理时已经记录了
    
    if (showToast && !isLoginModalShowing) {
      try {
        setLoginModalStatus(true)
      } catch (e) {}
      uni.showModal({
        title: '系统提示',
        content: '登录状态已过期或不存在，您可以选择稍后再登录。',
        showCancel: true,
        cancelText: '取消',
        confirmText: '一键登录',
        success: (res) => {
          try { setLoginModalStatus(false) } catch (e) {}
          if (res.confirm) {
            trackEvent('login_modal_confirm', { sourcePage: getSourcePage() || getCurrentPagePath() })
            if (autoRedirect) {
              uni.navigateTo({ url: redirectUrl })
            }
          } else {
            // 用户点击了取消，仅关闭弹窗，不触发登录
            trackEvent('login_modal_cancel', { sourcePage: getSourcePage() || getCurrentPagePath() })
          }
        },
        fail: () => {
          try { setLoginModalStatus(false) } catch (e) {}
        }
      })
    }
    return {
      isLoggedIn: false,
      token: '',
      userId: '',
      name: '',
      nickName: '',
      avatar: ''
    }
  }

  // 检查用户ID是否有效
  if (!userId || userId === 'default' || userId === '') {
    // 如果传入了sourcePage参数，则保存它
    if (sourcePage && sourcePage !== '/pages/login') {
      saveSourcePage(sourcePage)
    }
    // 注意：不再自动获取当前页面路径，因为401错误处理时已经记录了
    
    if (showToast && !isLoginModalShowing) {
      try { setLoginModalStatus(true) } catch (e) {}
      uni.showModal({
        title: '系统提示',
        content: '登录状态已过期，您可以继续留在该页面，或者重新登录',
        showCancel: true,
        cancelText: '取消',
        confirmText: '重新登录',
        success: (res) => {
          try { setLoginModalStatus(false) } catch (e) {}
          if (res.confirm) {
            // 用户选择重新登录
            trackEvent('login_modal_confirm', { sourcePage: getSourcePage() || getCurrentPagePath() })
            if (autoRedirect) {
              uni.navigateTo({ url: redirectUrl })
            }
          } else {
            // 用户选择留在该页面，不做任何操作
            trackEvent('login_modal_cancel', { sourcePage: getSourcePage() || getCurrentPagePath() })
          }
        },
        fail: () => {
          try { setLoginModalStatus(false) } catch (e) {}
        }
      })
    }
    return {
      isLoggedIn: false,
      token,
      userId: '',
      name: '',
      nickName: '',
      avatar: ''
    }
  }

  return {
    isLoggedIn: true,
    token,
    userId,
    name,
    nickName,
    avatar
  }
}

/**
 * 简化版登录检查，只返回布尔值
 * @param {Object} options 配置选项
 * @returns {boolean} 是否已登录
 */
export function isLoggedIn(options = {}) {
  const result = checkLoginStatus(options)
  return result.isLoggedIn
}

/**
 * 获取当前用户信息
 * @returns {Object} 用户信息 { token: string, userId: string }
 */
export function getCurrentUser() {
  const result = checkLoginStatus({ showToast: false, autoRedirect: false })
  return {
    token: result.token,
    userId: result.userId,
    name: result.name,
    nickName: result.nickName,
    avatar: result.avatar
  }
}

/**
 * 统一处理API响应中的401错误，参考request.js的逻辑
 * @param {Object} response API响应对象
 * @param {Object} options 配置选项
 * @returns {boolean} 是否处理了401错误
 */
export function handle401Error(response, options = {}) {
  const {
    autoRedirect = true,
    redirectUrl = '/pages/login'
  } = options

  if (response && response.data && response.data.code === 401) {
    
    // 在显示弹窗前记录当前页面路径
    const currentPagePath = getCurrentPagePath()
    if (currentPagePath !== '/pages/login') {
      saveSourcePage(currentPagePath)
    }
    
    // 防止重复弹窗
    if (isLoginModalShowing) {
      return true
    }
    
    isLoginModalShowing = true
    uni.showModal({
      title: '系统提示',
      content: '登录状态已过期或不存在，您需要重新登录。',
      showCancel: true,
      cancelText: '取消',
      confirmText: '一键登录',
      success: (res) => {
        // 重置弹窗状态
        isLoginModalShowing = false
        
        if (res.confirm) {
          // 只有用户点击确定才执行登录逻辑
          try {
            // 清除token
            uni.removeStorageSync('App-Token')
            // 清除用户信息
            uni.removeStorageSync('userId')
            uni.removeStorageSync('storage_data')
            // 清除store中的用户信息
            const app = getApp()
            if (app && app.$store && app.$store.dispatch) {
              app.$store.dispatch('LogOut')
            }
          } catch (error) {
            console.error('清除登录状态失败:', error)
          }
          
          if (autoRedirect) {
            uni.reLaunch({ url: redirectUrl })
          }
        } else {
          // 用户点击取消，不跳转，也不强制清除登录状态（虽然可能已经失效了）
        }
      },
      fail: () => {
        // 弹窗失败时也要重置状态
        isLoginModalShowing = false
      }
    })
    return true
  }
  return false
}

/**
 * 处理API请求错误，特别是401未授权错误
 * @param {Object} error 错误对象
 * @param {Object} options 配置选项
 */
export function handleApiError(error, options = {}) {
  const {
    showToast = true,
    autoRedirect = true,
    autoWechatLogin = true,
    redirectUrl = '/pages/login'
  } = options

  console.error('=== API请求错误 ===', error)

  if (error.response) {
    const status = error.response.status
    const data = error.response.data

    if (status === 401) {
      // 使用统一的401错误处理函数
      const response = { data: { code: 401 } }
      return handle401Error(response, { autoRedirect, redirectUrl })
    } else if (status === 403) {
      // 权限不足
      if (showToast) {
        uni.showToast({
          title: '没有权限访问该功能',
          icon: 'none'
        })
      }
      return true
    } else if (status === 500) {
      // 服务器错误
      const errorMsg = data?.msg || '未知错误'
      
      // 检查是否是用户信息相关的错误，如果是则显示确认弹窗
      if (errorMsg.includes('获取用户信息异常') || errorMsg.includes('用户信息异常') || errorMsg.includes('获取用户ID异常') || errorMsg.includes('用户ID不能为空') || errorMsg.includes('请先登录')) {
        if (showToast) {
          // 防止重复弹窗
          if (isLoginModalShowing) {
            return true
          }
          
          isLoginModalShowing = true
          uni.showModal({
            title: '系统提示',
            content: '登录状态已过期，您可以继续留在该页面，或者重新登录',
            showCancel: true,
            cancelText: '取消',
            confirmText: '重新登录',
            success: (res) => {
              // 重置弹窗状态
              isLoginModalShowing = false
              
              if (res.confirm) {
                // 用户选择重新登录，清除登录状态并跳转
                try {
                  // 清除token
                  uni.removeStorageSync('App-Token')
                  // 清除用户信息
                  uni.removeStorageSync('userId')
                  uni.removeStorageSync('storage_data')
                  // 清除store中的用户信息
                  const app = getApp()
                  if (app && app.$store && app.$store.dispatch) {
                    app.$store.dispatch('LogOut')
                  }
                } catch (error) {
                  console.error('清除登录状态失败:', error)
                }
                
                if (autoRedirect) {
                  uni.reLaunch({ url: redirectUrl })
                }
              }
              // 用户选择留在该页面，不做任何操作
            },
            fail: () => {
              // 弹窗失败时也要重置状态
              isLoginModalShowing = false
            }
          })
        }
      } else {
        // 其他服务器错误
        if (showToast) {
          uni.showToast({
            title: '服务器内部错误：' + errorMsg,
            icon: 'none'
          })
        }
      }
      return true
    }
  } else if (error.request) {
    // 网络错误
    if (showToast) {
      uni.showToast({
        title: '网络连接失败，请检查网络',
        icon: 'none'
      })
    }
    return true
  }

  return false // 未处理的错误
}



/**
 * 在页面加载时检查登录状态的混入
 */
export const loginCheckMixin = {
  methods: {
    // 检查登录状态
    checkLogin(options = {}) {
      return checkLoginStatus(options)
    },
    
    // 获取当前用户
    getCurrentUser() {
      return getCurrentUser()
    },
    
    // 处理API错误
    handleApiError(error, options = {}) {
      return handleApiError(error, options)
    }
  }
}

/**
 * 检查组织切换
 * 当检测到用户切换组织时，清除相关缓存
 * @param {string} currentUserId 当前用户ID
 */
function checkOrgSwitch(currentUserId) {
  try {
    // 获取上次记录的用户ID和组织ID
    const lastUserId = uni.getStorageSync('last_user_id')
    const lastOrgId = uni.getStorageSync('last_org_id')
    const currentOrgId = API_CONFIG.ORG_ID
    
    
    // 检查是否发生了组织切换
    const orgChanged = lastOrgId && lastOrgId !== currentOrgId
    const userChanged = lastUserId && lastUserId !== currentUserId
    
    if (orgChanged || userChanged) {
      
      // 清除旧组织的缓存
      if (orgChanged && lastOrgId) {
        cacheManager.clearOrgCache(lastOrgId)
      }
      
      // 清除当前组织的缓存（确保数据刷新）
      cacheManager.clearOrgCache(currentOrgId)
      
    }
    
    // 更新记录的用户ID和组织ID
    uni.setStorageSync('last_user_id', currentUserId)
    uni.setStorageSync('last_org_id', currentOrgId)
    
  } catch (error) {
    console.error('组织切换检查失败:', error)
  }
}
